import asyncio

from .middleware_node import MiddlewareNode
from .ptr import Ptr


def t(handler: callable):
    ...

class HttpMethodHandle:
    ''' http请求处理类 '''
    def __init__(self):
        self.middleware_head_node: MiddlewareNode = None
        self.middleware_end_node: MiddlewareNode = None
    
    async def middleware_handler(self, req, res):
        ''' 中间件层的处理函数 '''
        # 使用指针来表示当前处于中间件层的哪个节点
        ptr = Ptr(self.middleware_head_node, req)
        # 循环调用中间件
        while ptr.next_flag and ptr.middleware_node is not None:
            # 如果当前节点的规则匹配
            if ptr.middleware_node.rule(ptr):
                # 如果这个中间件是一个函数
                if ptr.middleware_node.func:
                    # 函数需要用户自行确认是否继续往下执行
                    ptr.next_flag = False
                    # 则直接执行
                    if asyncio.iscoroutinefunction(ptr.middleware_node.func):
                        await ptr.middleware_node.func(req, res, ptr.next)
                    else:
                        ptr.middleware_node.func(req, res, ptr.next)
                    # 进入下一个中间件进行匹配
                    ptr.middleware_node = ptr.middleware_node.next
                # 如果这个中间件是一个路由
                elif ptr.middleware_node.router:
                    # 则将路由的起始节点设置为当前节点
                    ptr.middleware_node = ptr.middleware_node.router.middleware_head_node
            else:
                # 否则进入下一个中间件进行匹配
                ptr.middleware_node = ptr.middleware_node.next

    def get(self, uri: str) -> callable:
        '''定义get请求的路由处理函数'''
        return t

    def post(self, uri: str) -> callable:
        '''定义POST请求的路由处理函数'''
        return t

    def put(self, uri: str) -> callable:
        '''定义PUT请求的路由处理函数'''
        return t

    def delete(self, uri: str) -> callable:
        '''定义DELETE请求的路由处理函数'''
        return t

    def options(self, uri: str) -> callable:
        '''定义OPTIONS请求的路由处理函数'''
        return t

    def head(self, uri: str) -> callable:
        '''定义HEAD请求的路由处理函数'''
        return t

    def patch(self, uri: str) -> callable:
        '''定义PATCH请求的路由处理函数'''
        return t

    def trace(self, uri: str) -> callable:
        '''定义TRACE请求的路由处理函数'''
        return t

    def connect(self, uri: str) -> callable:
        '''定义CONNECT请求的路由处理函数'''
        return t

    def copy(self, uri: str) -> callable:
        '''定义COPY请求的路由处理函数'''
        return t

    def link(self, uri: str) -> callable:
        '''定义LINK请求的路由处理函数'''
        return t

    def unlink(self, uri: str) -> callable:
        '''定义UNLINK请求的路由处理函数'''
        return t

    def purge(self, uri: str) -> callable:
        '''定义PURGE请求的路由处理函数'''
        return t

    def lock(self, uri: str) -> callable:
        '''定义LOCK请求的路由处理函数'''
        return t

    def unlock(self, uri: str) -> callable:
        '''定义UNLOCK请求的路由处理函数'''
        return t

    def mkcol(self, uri: str) -> callable:
        '''定义MKCOL请求的路由处理函数'''
        return t

    def move(self, uri: str) -> callable:
        '''定义MOVE请求的路由处理函数'''
        return t

    def propfind(self, uri: str) -> callable:
        '''定义PROPFIND请求的路由处理函数'''
        return t

    def report(self, uri: str) -> callable:
        '''定义REPORT请求的路由处理函数'''
        return t

    def view(self, uri: str) -> callable:
        '''定义VIEW请求的路由处理函数'''
        return t

    def all(self, uri: str) -> callable:
        '''定义所有请求的路由处理函数'''
        return t